//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Braket service.
///
/// The Amazon Braket API Reference provides information about the operations and structures supported by Amazon Braket. To learn about the permissions required to call an Amazon Braket API action, see Actions, resources, and condition keys for Amazon Braket. Amazon Braket Python SDK and the AWS Command Line Interface can be used to make discovery and creation of API calls easier. For more information about Amazon Braket features, see What is Amazon Braket? and important terms and concepts in the Amazon Braket Developer Guide.  In this guide:           CommonParameters     CommonErrors     Available languages for AWS SDK:     .NET     C++     Go API reference     Java     JavaScript     PHP     Python (Boto)     Ruby     Code examples from the Amazon Braket Tutorials GitHub repository:     Amazon Braket Examples
public struct Braket: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Braket client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Braket",
            serviceIdentifier: "braket",
            serviceProtocol: .restjson,
            apiVersion: "2019-09-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: BraketErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "eu-north-1": "braket.eu-north-1.api.aws",
            "eu-west-2": "braket.eu-west-2.api.aws",
            "us-east-1": "braket.us-east-1.api.aws",
            "us-west-1": "braket.us-west-1.api.aws",
            "us-west-2": "braket.us-west-2.api.aws"
        ])
    ]}

    // MARK: API Calls

    /// Cancels an Amazon Braket hybrid job.
    @Sendable
    @inlinable
    public func cancelJob(_ input: CancelJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelJobResponse {
        try await self.client.execute(
            operation: "CancelJob", 
            path: "/job/{jobArn}/cancel", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels an Amazon Braket hybrid job.
    ///
    /// Parameters:
    ///   - jobArn: The ARN of the Amazon Braket hybrid job to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelJob(
        jobArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelJobResponse {
        let input = CancelJobRequest(
            jobArn: jobArn
        )
        return try await self.cancelJob(input, logger: logger)
    }

    /// Cancels the specified task.
    @Sendable
    @inlinable
    public func cancelQuantumTask(_ input: CancelQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CancelQuantumTaskResponse {
        try await self.client.execute(
            operation: "CancelQuantumTask", 
            path: "/quantum-task/{quantumTaskArn}/cancel", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Cancels the specified task.
    ///
    /// Parameters:
    ///   - clientToken: The client token associated with the cancellation request.
    ///   - quantumTaskArn: The ARN of the quantum task to cancel.
    ///   - logger: Logger use during operation
    @inlinable
    public func cancelQuantumTask(
        clientToken: String = CancelQuantumTaskRequest.idempotencyToken(),
        quantumTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CancelQuantumTaskResponse {
        let input = CancelQuantumTaskRequest(
            clientToken: clientToken, 
            quantumTaskArn: quantumTaskArn
        )
        return try await self.cancelQuantumTask(input, logger: logger)
    }

    /// Creates an Amazon Braket hybrid job.
    @Sendable
    @inlinable
    public func createJob(_ input: CreateJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateJobResponse {
        try await self.client.execute(
            operation: "CreateJob", 
            path: "/job", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an Amazon Braket hybrid job.
    ///
    /// Parameters:
    ///   - algorithmSpecification: Definition of the Amazon Braket job to be created. Specifies the container image the job uses and information about the Python scripts used for entry and training.
    ///   - associations: The list of Amazon Braket resources associated with the hybrid job.
    ///   - checkpointConfig: Information about the output locations for hybrid job checkpoint data.
    ///   - clientToken: The client token associated with this request that guarantees that the request is idempotent.
    ///   - deviceConfig: The quantum processing unit (QPU) or simulator used to create an Amazon Braket hybrid job.
    ///   - hyperParameters: Algorithm-specific parameters used by an Amazon Braket hybrid job that influence the quality of the training job. The values are set with a map of JSON key:value pairs, where the key is the name of the hyperparameter and the value is the value of the hyperparameter.  Do not include any security-sensitive information including account access IDs, secrets, or tokens in any hyperparameter fields. As part of the shared responsibility model, you are responsible for any potential exposure, unauthorized access, or compromise of your sensitive data if caused by security-sensitive information included in the request hyperparameter variable or plain text fields.
    ///   - inputDataConfig: A list of parameters that specify the name and type of input data and where it is located.
    ///   - instanceConfig: Configuration of the resource instances to use while running the hybrid job on Amazon Braket.
    ///   - jobName: The name of the Amazon Braket hybrid job.
    ///   - outputDataConfig: The path to the S3 location where you want to store hybrid job artifacts and the encryption key used to store them.
    ///   - roleArn: The Amazon Resource Name (ARN) of an IAM role that Amazon Braket can assume to perform tasks on behalf of a user. It can access user resources, run an Amazon Braket job container on behalf of user, and output results and hybrid job details to the users' s3 buckets.
    ///   - stoppingCondition:  The user-defined criteria that specifies when a hybrid job stops running.
    ///   - tags: Tags to be added to the hybrid job you're creating.
    ///   - logger: Logger use during operation
    @inlinable
    public func createJob(
        algorithmSpecification: AlgorithmSpecification,
        associations: [Association]? = nil,
        checkpointConfig: JobCheckpointConfig? = nil,
        clientToken: String = CreateJobRequest.idempotencyToken(),
        deviceConfig: DeviceConfig,
        hyperParameters: [String: String]? = nil,
        inputDataConfig: [InputFileConfig]? = nil,
        instanceConfig: InstanceConfig,
        jobName: String,
        outputDataConfig: JobOutputDataConfig,
        roleArn: String,
        stoppingCondition: JobStoppingCondition? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateJobResponse {
        let input = CreateJobRequest(
            algorithmSpecification: algorithmSpecification, 
            associations: associations, 
            checkpointConfig: checkpointConfig, 
            clientToken: clientToken, 
            deviceConfig: deviceConfig, 
            hyperParameters: hyperParameters, 
            inputDataConfig: inputDataConfig, 
            instanceConfig: instanceConfig, 
            jobName: jobName, 
            outputDataConfig: outputDataConfig, 
            roleArn: roleArn, 
            stoppingCondition: stoppingCondition, 
            tags: tags
        )
        return try await self.createJob(input, logger: logger)
    }

    /// Creates a quantum task.
    @Sendable
    @inlinable
    public func createQuantumTask(_ input: CreateQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateQuantumTaskResponse {
        try await self.client.execute(
            operation: "CreateQuantumTask", 
            path: "/quantum-task", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a quantum task.
    ///
    /// Parameters:
    ///   - action: The action associated with the quantum task.
    ///   - associations: The list of Amazon Braket resources associated with the quantum task.
    ///   - clientToken: The client token associated with the request.
    ///   - deviceArn: The ARN of the device to run the quantum task on.
    ///   - deviceParameters: The parameters for the device to run the quantum task on.
    ///   - jobToken: The token for an Amazon Braket hybrid job that associates it with the quantum task.
    ///   - outputS3Bucket: The S3 bucket to store quantum task result files in.
    ///   - outputS3KeyPrefix: The key prefix for the location in the S3 bucket to store quantum task results in.
    ///   - shots: The number of shots to use for the quantum task.
    ///   - tags: Tags to be added to the quantum task you're creating.
    ///   - logger: Logger use during operation
    @inlinable
    public func createQuantumTask(
        action: String,
        associations: [Association]? = nil,
        clientToken: String = CreateQuantumTaskRequest.idempotencyToken(),
        deviceArn: String,
        deviceParameters: String? = nil,
        jobToken: String? = nil,
        outputS3Bucket: String,
        outputS3KeyPrefix: String,
        shots: Int64,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateQuantumTaskResponse {
        let input = CreateQuantumTaskRequest(
            action: action, 
            associations: associations, 
            clientToken: clientToken, 
            deviceArn: deviceArn, 
            deviceParameters: deviceParameters, 
            jobToken: jobToken, 
            outputS3Bucket: outputS3Bucket, 
            outputS3KeyPrefix: outputS3KeyPrefix, 
            shots: shots, 
            tags: tags
        )
        return try await self.createQuantumTask(input, logger: logger)
    }

    /// Retrieves the devices available in Amazon Braket.  For backwards compatibility with older versions of BraketSchemas, OpenQASM information is omitted from GetDevice API calls. To get this information the user-agent needs to present a recent version of the BraketSchemas (1.8.0 or later). The Braket SDK automatically reports this for you. If you do not see OpenQASM results in the GetDevice response when using a Braket SDK, you may need to set AWS_EXECUTION_ENV environment variable to configure user-agent. See the code examples provided below for how to do this for the AWS CLI, Boto3, and the Go, Java, and JavaScript/TypeScript SDKs.
    @Sendable
    @inlinable
    public func getDevice(_ input: GetDeviceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetDeviceResponse {
        try await self.client.execute(
            operation: "GetDevice", 
            path: "/device/{deviceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the devices available in Amazon Braket.  For backwards compatibility with older versions of BraketSchemas, OpenQASM information is omitted from GetDevice API calls. To get this information the user-agent needs to present a recent version of the BraketSchemas (1.8.0 or later). The Braket SDK automatically reports this for you. If you do not see OpenQASM results in the GetDevice response when using a Braket SDK, you may need to set AWS_EXECUTION_ENV environment variable to configure user-agent. See the code examples provided below for how to do this for the AWS CLI, Boto3, and the Go, Java, and JavaScript/TypeScript SDKs.
    ///
    /// Parameters:
    ///   - deviceArn: The ARN of the device to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getDevice(
        deviceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetDeviceResponse {
        let input = GetDeviceRequest(
            deviceArn: deviceArn
        )
        return try await self.getDevice(input, logger: logger)
    }

    /// Retrieves the specified Amazon Braket hybrid job.
    @Sendable
    @inlinable
    public func getJob(_ input: GetJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetJobResponse {
        try await self.client.execute(
            operation: "GetJob", 
            path: "/job/{jobArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the specified Amazon Braket hybrid job.
    ///
    /// Parameters:
    ///   - additionalAttributeNames: A list of attributes to return additional information for. Only the QueueInfo additional attribute name is currently supported.
    ///   - jobArn: The ARN of the hybrid job to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getJob(
        additionalAttributeNames: [HybridJobAdditionalAttributeName]? = nil,
        jobArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetJobResponse {
        let input = GetJobRequest(
            additionalAttributeNames: additionalAttributeNames, 
            jobArn: jobArn
        )
        return try await self.getJob(input, logger: logger)
    }

    /// Retrieves the specified quantum task.
    @Sendable
    @inlinable
    public func getQuantumTask(_ input: GetQuantumTaskRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetQuantumTaskResponse {
        try await self.client.execute(
            operation: "GetQuantumTask", 
            path: "/quantum-task/{quantumTaskArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the specified quantum task.
    ///
    /// Parameters:
    ///   - additionalAttributeNames: A list of attributes to return additional information for. Only the QueueInfo additional attribute name is currently supported.
    ///   - quantumTaskArn: The ARN of the quantum task to retrieve.
    ///   - logger: Logger use during operation
    @inlinable
    public func getQuantumTask(
        additionalAttributeNames: [QuantumTaskAdditionalAttributeName]? = nil,
        quantumTaskArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetQuantumTaskResponse {
        let input = GetQuantumTaskRequest(
            additionalAttributeNames: additionalAttributeNames, 
            quantumTaskArn: quantumTaskArn
        )
        return try await self.getQuantumTask(input, logger: logger)
    }

    /// Shows the tags associated with this resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Shows the tags associated with this resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn for the resource whose tags to display.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Searches for devices using the specified filters.
    @Sendable
    @inlinable
    public func searchDevices(_ input: SearchDevicesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchDevicesResponse {
        try await self.client.execute(
            operation: "SearchDevices", 
            path: "/devices", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for devices using the specified filters.
    ///
    /// Parameters:
    ///   - filters: Array of SearchDevicesFilter objects to use when searching for devices.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request to continue search where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchDevices(
        filters: [SearchDevicesFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchDevicesResponse {
        let input = SearchDevicesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchDevices(input, logger: logger)
    }

    /// Searches for Amazon Braket hybrid jobs that match the specified filter values.
    @Sendable
    @inlinable
    public func searchJobs(_ input: SearchJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchJobsResponse {
        try await self.client.execute(
            operation: "SearchJobs", 
            path: "/jobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for Amazon Braket hybrid jobs that match the specified filter values.
    ///
    /// Parameters:
    ///   - filters: Array of SearchJobsFilter objects to use when searching for hybrid jobs.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request to continue search where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchJobs(
        filters: [SearchJobsFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchJobsResponse {
        let input = SearchJobsRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchJobs(input, logger: logger)
    }

    /// Searches for tasks that match the specified filter values.
    @Sendable
    @inlinable
    public func searchQuantumTasks(_ input: SearchQuantumTasksRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchQuantumTasksResponse {
        try await self.client.execute(
            operation: "SearchQuantumTasks", 
            path: "/quantum-tasks", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for tasks that match the specified filter values.
    ///
    /// Parameters:
    ///   - filters: Array of SearchQuantumTasksFilter objects to use when searching for quantum tasks.
    ///   - maxResults: Maximum number of results to return in the response.
    ///   - nextToken: A token used for pagination of results returned in the response. Use the token returned from the previous request to continue search where the previous request ended.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchQuantumTasks(
        filters: [SearchQuantumTasksFilter],
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchQuantumTasksResponse {
        let input = SearchQuantumTasksRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchQuantumTasks(input, logger: logger)
    }

    /// Add a tag to the specified resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Add a tag to the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn of the resource to which a tag will be added.
    ///   - tags: Specify the tags to add to the resource. Tags can be specified as a key-value map.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Remove tags from a resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Remove tags from a resource.
    ///
    /// Parameters:
    ///   - resourceArn: Specify the resourceArn for the resource from which to remove the tags.
    ///   - tagKeys: Specify the keys for the tags to remove from the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }
}

extension Braket {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Braket, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Braket {
    /// Return PaginatorSequence for operation ``searchDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchDevicesPaginator(
        _ input: SearchDevicesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchDevicesRequest, SearchDevicesResponse> {
        return .init(
            input: input,
            command: self.searchDevices,
            inputKey: \SearchDevicesRequest.nextToken,
            outputKey: \SearchDevicesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchDevices(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Array of SearchDevicesFilter objects to use when searching for devices.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchDevicesPaginator(
        filters: [SearchDevicesFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchDevicesRequest, SearchDevicesResponse> {
        let input = SearchDevicesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchDevicesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchJobsPaginator(
        _ input: SearchJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchJobsRequest, SearchJobsResponse> {
        return .init(
            input: input,
            command: self.searchJobs,
            inputKey: \SearchJobsRequest.nextToken,
            outputKey: \SearchJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Array of SearchJobsFilter objects to use when searching for hybrid jobs.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchJobsPaginator(
        filters: [SearchJobsFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchJobsRequest, SearchJobsResponse> {
        let input = SearchJobsRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchQuantumTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuantumTasksPaginator(
        _ input: SearchQuantumTasksRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchQuantumTasksRequest, SearchQuantumTasksResponse> {
        return .init(
            input: input,
            command: self.searchQuantumTasks,
            inputKey: \SearchQuantumTasksRequest.nextToken,
            outputKey: \SearchQuantumTasksResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchQuantumTasks(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Array of SearchQuantumTasksFilter objects to use when searching for quantum tasks.
    ///   - maxResults: Maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchQuantumTasksPaginator(
        filters: [SearchQuantumTasksFilter],
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchQuantumTasksRequest, SearchQuantumTasksResponse> {
        let input = SearchQuantumTasksRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchQuantumTasksPaginator(input, logger: logger)
    }
}

extension Braket.SearchDevicesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchDevicesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Braket.SearchJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchJobsRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Braket.SearchQuantumTasksRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Braket.SearchQuantumTasksRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}
